# 1 "gnode.c"
# 1 "/Users/gdhuang/Documents/glib/glib//"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "gnode.c"
# 34 "gnode.c"
# 1 "../config.h" 1
# 35 "gnode.c" 2

# 1 "gnode.h" 1
# 34 "gnode.h"
# 1 "../glib/gmem.h" 1
# 34 "../glib/gmem.h"
# 1 "../glib/gtypes.h" 1
# 34 "../glib/gtypes.h"
# 1 "./glibconfig.h" 1
# 9 "./glibconfig.h"
# 1 "../glib/gmacros.h" 1
# 40 "../glib/gmacros.h"
# 1 "/usr/llvm-gcc-4.2/bin/../lib/gcc/i686-apple-darwin11/4.2.1/include/stddef.h" 1 3 4
# 152 "/usr/llvm-gcc-4.2/bin/../lib/gcc/i686-apple-darwin11/4.2.1/include/stddef.h" 3 4
typedef long int ptrdiff_t;
# 214 "/usr/llvm-gcc-4.2/bin/../lib/gcc/i686-apple-darwin11/4.2.1/include/stddef.h" 3 4
typedef long unsigned int size_t;
# 326 "/usr/llvm-gcc-4.2/bin/../lib/gcc/i686-apple-darwin11/4.2.1/include/stddef.h" 3 4
typedef int wchar_t;
# 41 "../glib/gmacros.h" 2
# 10 "./glibconfig.h" 2

# 1 "/usr/llvm-gcc-4.2/bin/../lib/gcc/i686-apple-darwin11/4.2.1/include/limits.h" 1 3 4






# 1 "/usr/llvm-gcc-4.2/bin/../lib/gcc/i686-apple-darwin11/4.2.1/include/syslimits.h" 1 3 4
# 8 "/usr/llvm-gcc-4.2/bin/../lib/gcc/i686-apple-darwin11/4.2.1/include/limits.h" 2 3 4







# 1 "/Applications/Xcode.app/Contents/Developer/usr/llvm-gcc-4.2/lib/gcc/i686-apple-darwin11/4.2.1/include/limits.h" 1 3 4






# 1 "/Applications/Xcode.app/Contents/Developer/usr/llvm-gcc-4.2/lib/gcc/i686-apple-darwin11/4.2.1/include/syslimits.h" 1 3 4
# 8 "/Applications/Xcode.app/Contents/Developer/usr/llvm-gcc-4.2/lib/gcc/i686-apple-darwin11/4.2.1/include/limits.h" 2 3 4







# 1 "/usr/include/limits.h" 1 3 4
# 63 "/usr/include/limits.h" 3 4
# 1 "/usr/include/sys/cdefs.h" 1 3 4
# 417 "/usr/include/sys/cdefs.h" 3 4
# 1 "/usr/include/sys/_symbol_aliasing.h" 1 3 4
# 418 "/usr/include/sys/cdefs.h" 2 3 4
# 494 "/usr/include/sys/cdefs.h" 3 4
# 1 "/usr/include/sys/_posix_availability.h" 1 3 4
# 495 "/usr/include/sys/cdefs.h" 2 3 4
# 64 "/usr/include/limits.h" 2 3 4
# 1 "/usr/include/machine/limits.h" 1 3 4





# 1 "/usr/include/i386/limits.h" 1 3 4
# 40 "/usr/include/i386/limits.h" 3 4
# 1 "/usr/include/i386/_limits.h" 1 3 4
# 41 "/usr/include/i386/limits.h" 2 3 4
# 7 "/usr/include/machine/limits.h" 2 3 4
# 65 "/usr/include/limits.h" 2 3 4
# 1 "/usr/include/sys/syslimits.h" 1 3 4
# 66 "/usr/include/limits.h" 2 3 4
# 16 "/Applications/Xcode.app/Contents/Developer/usr/llvm-gcc-4.2/lib/gcc/i686-apple-darwin11/4.2.1/include/limits.h" 2 3 4
# 16 "/usr/llvm-gcc-4.2/bin/../lib/gcc/i686-apple-darwin11/4.2.1/include/limits.h" 2 3 4
# 12 "./glibconfig.h" 2
# 1 "/usr/llvm-gcc-4.2/bin/../lib/gcc/i686-apple-darwin11/4.2.1/include/float.h" 1 3 4
# 13 "./glibconfig.h" 2
# 22 "./glibconfig.h"

# 38 "./glibconfig.h"
typedef signed char gint8;
typedef unsigned char guint8;
typedef signed short gint16;
typedef unsigned short guint16;



typedef signed int gint32;
typedef unsigned int guint32;





typedef signed long gint64;
typedef unsigned long guint64;
# 65 "./glibconfig.h"
typedef signed long gssize;
typedef unsigned long gsize;
# 75 "./glibconfig.h"
typedef gint64 goffset;
# 90 "./glibconfig.h"
typedef signed long gintptr;
typedef unsigned long guintptr;
# 195 "./glibconfig.h"
typedef int GPid;
# 205 "./glibconfig.h"

# 35 "../glib/gtypes.h" 2
# 1 "../glib/gmacros.h" 1
# 36 "../glib/gtypes.h" 2
# 1 "../glib/gversionmacros.h" 1
# 37 "../glib/gtypes.h" 2
# 1 "/usr/include/time.h" 1 3 4
# 66 "/usr/include/time.h" 3 4
# 1 "/usr/include/_types.h" 1 3 4
# 27 "/usr/include/_types.h" 3 4
# 1 "/usr/include/sys/_types.h" 1 3 4
# 33 "/usr/include/sys/_types.h" 3 4
# 1 "/usr/include/machine/_types.h" 1 3 4
# 32 "/usr/include/machine/_types.h" 3 4
# 1 "/usr/include/i386/_types.h" 1 3 4
# 37 "/usr/include/i386/_types.h" 3 4
typedef signed char __int8_t;



typedef unsigned char __uint8_t;
typedef short __int16_t;
typedef unsigned short __uint16_t;
typedef int __int32_t;
typedef unsigned int __uint32_t;
typedef long long __int64_t;
typedef unsigned long long __uint64_t;

typedef long __darwin_intptr_t;
typedef unsigned int __darwin_natural_t;
# 70 "/usr/include/i386/_types.h" 3 4
typedef int __darwin_ct_rune_t;





typedef union {
 char __mbstate8[128];
 long long _mbstateL;
} __mbstate_t;

typedef __mbstate_t __darwin_mbstate_t;


typedef long int __darwin_ptrdiff_t;





typedef long unsigned int __darwin_size_t;





typedef __builtin_va_list __darwin_va_list;





typedef int __darwin_wchar_t;




typedef __darwin_wchar_t __darwin_rune_t;


typedef int __darwin_wint_t;




typedef unsigned long __darwin_clock_t;
typedef __uint32_t __darwin_socklen_t;
typedef long __darwin_ssize_t;
typedef long __darwin_time_t;
# 33 "/usr/include/machine/_types.h" 2 3 4
# 34 "/usr/include/sys/_types.h" 2 3 4
# 58 "/usr/include/sys/_types.h" 3 4
struct __darwin_pthread_handler_rec
{
 void (*__routine)(void *);
 void *__arg;
 struct __darwin_pthread_handler_rec *__next;
};
struct _opaque_pthread_attr_t { long __sig; char __opaque[56]; };
struct _opaque_pthread_cond_t { long __sig; char __opaque[40]; };
struct _opaque_pthread_condattr_t { long __sig; char __opaque[8]; };
struct _opaque_pthread_mutex_t { long __sig; char __opaque[56]; };
struct _opaque_pthread_mutexattr_t { long __sig; char __opaque[8]; };
struct _opaque_pthread_once_t { long __sig; char __opaque[8]; };
struct _opaque_pthread_rwlock_t { long __sig; char __opaque[192]; };
struct _opaque_pthread_rwlockattr_t { long __sig; char __opaque[16]; };
struct _opaque_pthread_t { long __sig; struct __darwin_pthread_handler_rec *__cleanup_stack; char __opaque[1168]; };
# 94 "/usr/include/sys/_types.h" 3 4
typedef __int64_t __darwin_blkcnt_t;
typedef __int32_t __darwin_blksize_t;
typedef __int32_t __darwin_dev_t;
typedef unsigned int __darwin_fsblkcnt_t;
typedef unsigned int __darwin_fsfilcnt_t;
typedef __uint32_t __darwin_gid_t;
typedef __uint32_t __darwin_id_t;
typedef __uint64_t __darwin_ino64_t;

typedef __darwin_ino64_t __darwin_ino_t;



typedef __darwin_natural_t __darwin_mach_port_name_t;
typedef __darwin_mach_port_name_t __darwin_mach_port_t;
typedef __uint16_t __darwin_mode_t;
typedef __int64_t __darwin_off_t;
typedef __int32_t __darwin_pid_t;
typedef struct _opaque_pthread_attr_t
   __darwin_pthread_attr_t;
typedef struct _opaque_pthread_cond_t
   __darwin_pthread_cond_t;
typedef struct _opaque_pthread_condattr_t
   __darwin_pthread_condattr_t;
typedef unsigned long __darwin_pthread_key_t;
typedef struct _opaque_pthread_mutex_t
   __darwin_pthread_mutex_t;
typedef struct _opaque_pthread_mutexattr_t
   __darwin_pthread_mutexattr_t;
typedef struct _opaque_pthread_once_t
   __darwin_pthread_once_t;
typedef struct _opaque_pthread_rwlock_t
   __darwin_pthread_rwlock_t;
typedef struct _opaque_pthread_rwlockattr_t
   __darwin_pthread_rwlockattr_t;
typedef struct _opaque_pthread_t
   *__darwin_pthread_t;
typedef __uint32_t __darwin_sigset_t;
typedef __int32_t __darwin_suseconds_t;
typedef __uint32_t __darwin_uid_t;
typedef __uint32_t __darwin_useconds_t;
typedef unsigned char __darwin_uuid_t[16];
typedef char __darwin_uuid_string_t[37];
# 28 "/usr/include/_types.h" 2 3 4
# 39 "/usr/include/_types.h" 3 4
typedef int __darwin_nl_item;
typedef int __darwin_wctrans_t;

typedef __uint32_t __darwin_wctype_t;
# 67 "/usr/include/time.h" 2 3 4


# 1 "/usr/include/_structs.h" 1 3 4
# 24 "/usr/include/_structs.h" 3 4
# 1 "/usr/include/sys/_structs.h" 1 3 4
# 88 "/usr/include/sys/_structs.h" 3 4
struct timespec
{
 __darwin_time_t tv_sec;
 long tv_nsec;
};
# 25 "/usr/include/_structs.h" 2 3 4
# 70 "/usr/include/time.h" 2 3 4







typedef __darwin_clock_t clock_t;
# 87 "/usr/include/time.h" 3 4
typedef __darwin_time_t time_t;


struct tm {
 int tm_sec;
 int tm_min;
 int tm_hour;
 int tm_mday;
 int tm_mon;
 int tm_year;
 int tm_wday;
 int tm_yday;
 int tm_isdst;
 long tm_gmtoff;
 char *tm_zone;
};
# 113 "/usr/include/time.h" 3 4
extern char *tzname[];


extern int getdate_err;

extern long timezone __asm("_" "timezone" );

extern int daylight;


char *asctime(const struct tm *);
clock_t clock(void) __asm("_" "clock" );
char *ctime(const time_t *);
double difftime(time_t, time_t);
struct tm *getdate(const char *);
struct tm *gmtime(const time_t *);
struct tm *localtime(const time_t *);
time_t mktime(struct tm *) __asm("_" "mktime" );
size_t strftime(char * , size_t, const char * , const struct tm * ) __asm("_" "strftime" );
char *strptime(const char * , const char * , struct tm * ) __asm("_" "strptime" );
time_t time(time_t *);


void tzset(void);



char *asctime_r(const struct tm * , char * );
char *ctime_r(const time_t *, char *);
struct tm *gmtime_r(const time_t * , struct tm * );
struct tm *localtime_r(const time_t * , struct tm * );


time_t posix2time(time_t);



void tzsetwall(void);
time_t time2posix(time_t);
time_t timelocal(struct tm * const);
time_t timegm(struct tm * const);



int nanosleep(const struct timespec *, struct timespec *) __asm("_" "nanosleep" );


# 38 "../glib/gtypes.h" 2


# 48 "../glib/gtypes.h"
typedef char gchar;
typedef short gshort;
typedef long glong;
typedef int gint;
typedef gint gboolean;

typedef unsigned char guchar;
typedef unsigned short gushort;
typedef unsigned long gulong;
typedef unsigned int guint;

typedef float gfloat;
typedef double gdouble;
# 79 "../glib/gtypes.h"
typedef void* gpointer;
typedef const void *gconstpointer;

typedef gint (*GCompareFunc) (gconstpointer a,
                                                 gconstpointer b);
typedef gint (*GCompareDataFunc) (gconstpointer a,
                                                 gconstpointer b,
       gpointer user_data);
typedef gboolean (*GEqualFunc) (gconstpointer a,
                                                 gconstpointer b);
typedef void (*GDestroyNotify) (gpointer data);
typedef void (*GFunc) (gpointer data,
                                                 gpointer user_data);
typedef guint (*GHashFunc) (gconstpointer key);
typedef void (*GHFunc) (gpointer key,
                                                 gpointer value,
                                                 gpointer user_data);
# 105 "../glib/gtypes.h"
typedef void (*GFreeFunc) (gpointer data);
# 119 "../glib/gtypes.h"
typedef const gchar * (*GTranslateFunc) (const gchar *str,
       gpointer data);
# 401 "../glib/gtypes.h"
typedef union _GDoubleIEEE754 GDoubleIEEE754;
typedef union _GFloatIEEE754 GFloatIEEE754;





union _GFloatIEEE754
{
  gfloat v_float;
  struct {
    guint mantissa : 23;
    guint biased_exponent : 8;
    guint sign : 1;
  } mpn;
};
union _GDoubleIEEE754
{
  gdouble v_double;
  struct {
    guint mantissa_low : 32;
    guint mantissa_high : 20;
    guint biased_exponent : 11;
    guint sign : 1;
  } mpn;
};
# 451 "../glib/gtypes.h"
typedef struct _GTimeVal GTimeVal;

struct _GTimeVal
{
  glong tv_sec;
  glong tv_usec;
};


# 35 "../glib/gmem.h" 2


# 51 "../glib/gmem.h"
typedef struct _GMemVTable GMemVTable;
# 70 "../glib/gmem.h"
void g_free (gpointer mem);


void g_clear_pointer (gpointer *pp,
                           GDestroyNotify destroy);

gpointer g_malloc (gsize n_bytes) __attribute__((__malloc__)) ;
gpointer g_malloc0 (gsize n_bytes) __attribute__((__malloc__)) ;
gpointer g_realloc (gpointer mem,
      gsize n_bytes) __attribute__((warn_unused_result));
gpointer g_try_malloc (gsize n_bytes) __attribute__((__malloc__)) ;
gpointer g_try_malloc0 (gsize n_bytes) __attribute__((__malloc__)) ;
gpointer g_try_realloc (gpointer mem,
      gsize n_bytes) __attribute__((warn_unused_result));

gpointer g_malloc_n (gsize n_blocks,
      gsize n_block_bytes) __attribute__((__malloc__)) ;
gpointer g_malloc0_n (gsize n_blocks,
      gsize n_block_bytes) __attribute__((__malloc__)) ;
gpointer g_realloc_n (gpointer mem,
      gsize n_blocks,
      gsize n_block_bytes) __attribute__((warn_unused_result));
gpointer g_try_malloc_n (gsize n_blocks,
      gsize n_block_bytes) __attribute__((__malloc__)) ;
gpointer g_try_malloc0_n (gsize n_blocks,
      gsize n_block_bytes) __attribute__((__malloc__)) ;
gpointer g_try_realloc_n (gpointer mem,
      gsize n_blocks,
      gsize n_block_bytes) __attribute__((warn_unused_result));
# 261 "../glib/gmem.h"
struct _GMemVTable {
  gpointer (*malloc) (gsize n_bytes);
  gpointer (*realloc) (gpointer mem,
      gsize n_bytes);
  void (*free) (gpointer mem);

  gpointer (*calloc) (gsize n_blocks,
      gsize n_block_bytes);
  gpointer (*try_malloc) (gsize n_bytes);
  gpointer (*try_realloc) (gpointer mem,
      gsize n_bytes);
};
void g_mem_set_vtable (GMemVTable *vtable);
gboolean g_mem_is_system_malloc (void);

extern gboolean g_mem_gc_friendly;



extern GMemVTable *glib_mem_profiler_table;
void g_mem_profile (void);


# 35 "gnode.h" 2



typedef struct _GNode GNode;


typedef enum
{
  G_TRAVERSE_LEAVES = 1 << 0,
  G_TRAVERSE_NON_LEAVES = 1 << 1,
  G_TRAVERSE_ALL = G_TRAVERSE_LEAVES | G_TRAVERSE_NON_LEAVES,
  G_TRAVERSE_MASK = 0x03,
  G_TRAVERSE_LEAFS = G_TRAVERSE_LEAVES,
  G_TRAVERSE_NON_LEAFS = G_TRAVERSE_NON_LEAVES
} GTraverseFlags;


typedef enum
{
  G_IN_ORDER,
  G_PRE_ORDER,
  G_POST_ORDER,
  G_LEVEL_ORDER
} GTraverseType;

typedef gboolean (*GNodeTraverseFunc) (GNode *node,
       gpointer data);
typedef void (*GNodeForeachFunc) (GNode *node,
       gpointer data);
# 77 "gnode.h"
typedef gpointer (*GCopyFunc) (gconstpointer src,
                                                 gpointer data);



struct _GNode
{
  gpointer data;
  GNode *next;
  GNode *prev;
  GNode *parent;
  GNode *children;
};
# 115 "gnode.h"
GNode* g_node_new (gpointer data);
void g_node_destroy (GNode *root);
void g_node_unlink (GNode *node);
GNode* g_node_copy_deep (GNode *node,
     GCopyFunc copy_func,
     gpointer data);
GNode* g_node_copy (GNode *node);
GNode* g_node_insert (GNode *parent,
     gint position,
     GNode *node);
GNode* g_node_insert_before (GNode *parent,
     GNode *sibling,
     GNode *node);
GNode* g_node_insert_after (GNode *parent,
     GNode *sibling,
     GNode *node);
GNode* g_node_prepend (GNode *parent,
     GNode *node);
guint g_node_n_nodes (GNode *root,
     GTraverseFlags flags);
GNode* g_node_get_root (GNode *node);
gboolean g_node_is_ancestor (GNode *node,
     GNode *descendant);
guint g_node_depth (GNode *node);
GNode* g_node_find (GNode *root,
     GTraverseType order,
     GTraverseFlags flags,
     gpointer data);
# 226 "gnode.h"
void g_node_traverse (GNode *root,
     GTraverseType order,
     GTraverseFlags flags,
     gint max_depth,
     GNodeTraverseFunc func,
     gpointer data);






guint g_node_max_height (GNode *root);

void g_node_children_foreach (GNode *node,
      GTraverseFlags flags,
      GNodeForeachFunc func,
      gpointer data);
void g_node_reverse_children (GNode *node);
guint g_node_n_children (GNode *node);
GNode* g_node_nth_child (GNode *node,
      guint n);
GNode* g_node_last_child (GNode *node);
GNode* g_node_find_child (GNode *node,
      GTraverseFlags flags,
      gpointer data);
gint g_node_child_position (GNode *node,
      GNode *child);
gint g_node_child_index (GNode *node,
      gpointer data);

GNode* g_node_first_sibling (GNode *node);
GNode* g_node_last_sibling (GNode *node);
# 296 "gnode.h"

# 37 "gnode.c" 2

# 1 "gslice.h" 1
# 27 "gslice.h"
# 1 "../glib/gtypes.h" 1
# 28 "gslice.h" 2





gpointer g_slice_alloc (gsize block_size) __attribute__((__malloc__)) ;
gpointer g_slice_alloc0 (gsize block_size) __attribute__((__malloc__)) ;
gpointer g_slice_copy (gsize block_size,
                                         gconstpointer mem_block) __attribute__((__malloc__)) ;
void g_slice_free1 (gsize block_size,
      gpointer mem_block);
void g_slice_free_chain_with_offset (gsize block_size,
      gpointer mem_chain,
      gsize next_offset);
# 72 "gslice.h"
typedef enum {
  G_SLICE_CONFIG_ALWAYS_MALLOC = 1,
  G_SLICE_CONFIG_BYPASS_MAGAZINES,
  G_SLICE_CONFIG_WORKING_SET_MSECS,
  G_SLICE_CONFIG_COLOR_INCREMENT,
  G_SLICE_CONFIG_CHUNK_SIZES,
  G_SLICE_CONFIG_CONTENTION_COUNTER
} GSliceConfig;
void g_slice_set_config (GSliceConfig ckey, gint64 value);
gint64 g_slice_get_config (GSliceConfig ckey);
gint64* g_slice_get_config_state (GSliceConfig ckey, gint64 address, guint *n_values);


# 39 "gnode.c" 2

# 1 "gtestutils.h" 1
# 28 "gtestutils.h"
# 1 "../glib/gmessages.h" 1
# 34 "../glib/gmessages.h"
# 1 "/usr/llvm-gcc-4.2/bin/../lib/gcc/i686-apple-darwin11/4.2.1/include/stdarg.h" 1 3 4
# 43 "/usr/llvm-gcc-4.2/bin/../lib/gcc/i686-apple-darwin11/4.2.1/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 105 "/usr/llvm-gcc-4.2/bin/../lib/gcc/i686-apple-darwin11/4.2.1/include/stdarg.h" 3 4
typedef __gnuc_va_list va_list;
# 35 "../glib/gmessages.h" 2
# 1 "../glib/gtypes.h" 1
# 36 "../glib/gmessages.h" 2
# 1 "../glib/gmacros.h" 1
# 37 "../glib/gmessages.h" 2




       
# 42 "../glib/gmessages.h" 3






gsize g_printf_string_upper_bound (const gchar* format,
         va_list args);
# 58 "../glib/gmessages.h" 3
typedef enum
{

  G_LOG_FLAG_RECURSION = 1 << 0,
  G_LOG_FLAG_FATAL = 1 << 1,


  G_LOG_LEVEL_ERROR = 1 << 2,
  G_LOG_LEVEL_CRITICAL = 1 << 3,
  G_LOG_LEVEL_WARNING = 1 << 4,
  G_LOG_LEVEL_MESSAGE = 1 << 5,
  G_LOG_LEVEL_INFO = 1 << 6,
  G_LOG_LEVEL_DEBUG = 1 << 7,

  G_LOG_LEVEL_MASK = ~(G_LOG_FLAG_RECURSION | G_LOG_FLAG_FATAL)
} GLogLevelFlags;




typedef void (*GLogFunc) (const gchar *log_domain,
                                                 GLogLevelFlags log_level,
                                                 const gchar *message,
                                                 gpointer user_data);



guint g_log_set_handler (const gchar *log_domain,
                                         GLogLevelFlags log_levels,
                                         GLogFunc log_func,
                                         gpointer user_data);
void g_log_remove_handler (const gchar *log_domain,
                                         guint handler_id);
void g_log_default_handler (const gchar *log_domain,
                                         GLogLevelFlags log_level,
                                         const gchar *message,
                                         gpointer unused_data);
GLogFunc g_log_set_default_handler (GLogFunc log_func,
        gpointer user_data);
void g_log (const gchar *log_domain,
                                         GLogLevelFlags log_level,
                                         const gchar *format,
                                         ...) __attribute__((__format__ (__printf__, 3, 4)));
void g_logv (const gchar *log_domain,
                                         GLogLevelFlags log_level,
                                         const gchar *format,
                                         va_list args);
GLogLevelFlags g_log_set_fatal_mask (const gchar *log_domain,
                                         GLogLevelFlags fatal_mask);
GLogLevelFlags g_log_set_always_fatal (GLogLevelFlags fatal_mask);


 void _g_log_fallback_handler (const gchar *log_domain,
       GLogLevelFlags log_level,
       const gchar *message,
       gpointer unused_data);


void g_return_if_fail_warning (const char *log_domain,
          const char *pretty_function,
          const char *expression);
void g_warn_message (const char *domain,
                               const char *file,
                               int line,
                               const char *func,
                               const char *warnexpr);
__attribute__((__deprecated__))
void g_assert_warning (const char *log_domain,
          const char *file,
          const int line,
                 const char *pretty_function,
                 const char *expression) __attribute__((__noreturn__));
# 235 "../glib/gmessages.h" 3
typedef void (*GPrintFunc) (const gchar *string);
void g_print (const gchar *format,
                                         ...) __attribute__((__format__ (__printf__, 1, 2)));
GPrintFunc g_set_print_handler (GPrintFunc func);
void g_printerr (const gchar *format,
                                         ...) __attribute__((__format__ (__printf__, 1, 2)));
GPrintFunc g_set_printerr_handler (GPrintFunc func);
# 402 "../glib/gmessages.h" 3

# 29 "gtestutils.h" 2
# 1 "../glib/gstring.h" 1
# 34 "../glib/gstring.h"
# 1 "../glib/gtypes.h" 1
# 35 "../glib/gstring.h" 2
# 1 "../glib/gunicode.h" 1
# 29 "../glib/gunicode.h"
# 1 "../glib/gerror.h" 1
# 30 "../glib/gerror.h"
# 1 "../glib/gquark.h" 1
# 34 "../glib/gquark.h"
# 1 "../glib/gtypes.h" 1
# 35 "../glib/gquark.h" 2



typedef guint32 GQuark;



GQuark g_quark_try_string (const gchar *string);
GQuark g_quark_from_static_string (const gchar *string);
GQuark g_quark_from_string (const gchar *string);
const gchar * g_quark_to_string (GQuark quark) __attribute__((__const__));

const gchar * g_intern_string (const gchar *string);
const gchar * g_intern_static_string (const gchar *string);


# 31 "../glib/gerror.h" 2


# 43 "../glib/gerror.h"
typedef struct _GError GError;

struct _GError
{
  GQuark domain;
  gint code;
  gchar *message;
};

GError* g_error_new (GQuark domain,
                                gint code,
                                const gchar *format,
                                ...) __attribute__((__format__ (__printf__, 3, 4)));

GError* g_error_new_literal (GQuark domain,
                                gint code,
                                const gchar *message);
GError* g_error_new_valist (GQuark domain,
                                gint code,
                                const gchar *format,
                                va_list args);

void g_error_free (GError *error);
GError* g_error_copy (const GError *error);

gboolean g_error_matches (const GError *error,
                                GQuark domain,
                                gint code);




void g_set_error (GError **err,
                                GQuark domain,
                                gint code,
                                const gchar *format,
                                ...) __attribute__((__format__ (__printf__, 4, 5)));

void g_set_error_literal (GError **err,
                                GQuark domain,
                                gint code,
                                const gchar *message);



void g_propagate_error (GError **dest,
    GError *src);


void g_clear_error (GError **err);


void g_prefix_error (GError **err,
                                       const gchar *format,
                                       ...) __attribute__((__format__ (__printf__, 2, 3)));


void g_propagate_prefixed_error (GError **dest,
                                       GError *src,
                                       const gchar *format,
                                       ...) __attribute__((__format__ (__printf__, 3, 4)));


# 30 "../glib/gunicode.h" 2
# 1 "../glib/gtypes.h" 1
# 31 "../glib/gunicode.h" 2


# 61 "../glib/gunicode.h"
typedef guint32 gunichar;
# 79 "../glib/gunicode.h"
typedef guint16 gunichar2;
# 118 "../glib/gunicode.h"
typedef enum
{
  G_UNICODE_CONTROL,
  G_UNICODE_FORMAT,
  G_UNICODE_UNASSIGNED,
  G_UNICODE_PRIVATE_USE,
  G_UNICODE_SURROGATE,
  G_UNICODE_LOWERCASE_LETTER,
  G_UNICODE_MODIFIER_LETTER,
  G_UNICODE_OTHER_LETTER,
  G_UNICODE_TITLECASE_LETTER,
  G_UNICODE_UPPERCASE_LETTER,
  G_UNICODE_SPACING_MARK,
  G_UNICODE_ENCLOSING_MARK,
  G_UNICODE_NON_SPACING_MARK,
  G_UNICODE_DECIMAL_NUMBER,
  G_UNICODE_LETTER_NUMBER,
  G_UNICODE_OTHER_NUMBER,
  G_UNICODE_CONNECT_PUNCTUATION,
  G_UNICODE_DASH_PUNCTUATION,
  G_UNICODE_CLOSE_PUNCTUATION,
  G_UNICODE_FINAL_PUNCTUATION,
  G_UNICODE_INITIAL_PUNCTUATION,
  G_UNICODE_OTHER_PUNCTUATION,
  G_UNICODE_OPEN_PUNCTUATION,
  G_UNICODE_CURRENCY_SYMBOL,
  G_UNICODE_MODIFIER_SYMBOL,
  G_UNICODE_MATH_SYMBOL,
  G_UNICODE_OTHER_SYMBOL,
  G_UNICODE_LINE_SEPARATOR,
  G_UNICODE_PARAGRAPH_SEPARATOR,
  G_UNICODE_SPACE_SEPARATOR
} GUnicodeType;
# 214 "../glib/gunicode.h"
typedef enum
{
  G_UNICODE_BREAK_MANDATORY,
  G_UNICODE_BREAK_CARRIAGE_RETURN,
  G_UNICODE_BREAK_LINE_FEED,
  G_UNICODE_BREAK_COMBINING_MARK,
  G_UNICODE_BREAK_SURROGATE,
  G_UNICODE_BREAK_ZERO_WIDTH_SPACE,
  G_UNICODE_BREAK_INSEPARABLE,
  G_UNICODE_BREAK_NON_BREAKING_GLUE,
  G_UNICODE_BREAK_CONTINGENT,
  G_UNICODE_BREAK_SPACE,
  G_UNICODE_BREAK_AFTER,
  G_UNICODE_BREAK_BEFORE,
  G_UNICODE_BREAK_BEFORE_AND_AFTER,
  G_UNICODE_BREAK_HYPHEN,
  G_UNICODE_BREAK_NON_STARTER,
  G_UNICODE_BREAK_OPEN_PUNCTUATION,
  G_UNICODE_BREAK_CLOSE_PUNCTUATION,
  G_UNICODE_BREAK_QUOTATION,
  G_UNICODE_BREAK_EXCLAMATION,
  G_UNICODE_BREAK_IDEOGRAPHIC,
  G_UNICODE_BREAK_NUMERIC,
  G_UNICODE_BREAK_INFIX_SEPARATOR,
  G_UNICODE_BREAK_SYMBOL,
  G_UNICODE_BREAK_ALPHABETIC,
  G_UNICODE_BREAK_PREFIX,
  G_UNICODE_BREAK_POSTFIX,
  G_UNICODE_BREAK_COMPLEX_CONTEXT,
  G_UNICODE_BREAK_AMBIGUOUS,
  G_UNICODE_BREAK_UNKNOWN,
  G_UNICODE_BREAK_NEXT_LINE,
  G_UNICODE_BREAK_WORD_JOINER,
  G_UNICODE_BREAK_HANGUL_L_JAMO,
  G_UNICODE_BREAK_HANGUL_V_JAMO,
  G_UNICODE_BREAK_HANGUL_T_JAMO,
  G_UNICODE_BREAK_HANGUL_LV_SYLLABLE,
  G_UNICODE_BREAK_HANGUL_LVT_SYLLABLE,
  G_UNICODE_BREAK_CLOSE_PARANTHESIS,
  G_UNICODE_BREAK_CONDITIONAL_JAPANESE_STARTER,
  G_UNICODE_BREAK_HEBREW_LETTER
} GUnicodeBreakType;
# 387 "../glib/gunicode.h"
typedef enum
{
  G_UNICODE_SCRIPT_INVALID_CODE = -1,
  G_UNICODE_SCRIPT_COMMON = 0,
  G_UNICODE_SCRIPT_INHERITED,
  G_UNICODE_SCRIPT_ARABIC,
  G_UNICODE_SCRIPT_ARMENIAN,
  G_UNICODE_SCRIPT_BENGALI,
  G_UNICODE_SCRIPT_BOPOMOFO,
  G_UNICODE_SCRIPT_CHEROKEE,
  G_UNICODE_SCRIPT_COPTIC,
  G_UNICODE_SCRIPT_CYRILLIC,
  G_UNICODE_SCRIPT_DESERET,
  G_UNICODE_SCRIPT_DEVANAGARI,
  G_UNICODE_SCRIPT_ETHIOPIC,
  G_UNICODE_SCRIPT_GEORGIAN,
  G_UNICODE_SCRIPT_GOTHIC,
  G_UNICODE_SCRIPT_GREEK,
  G_UNICODE_SCRIPT_GUJARATI,
  G_UNICODE_SCRIPT_GURMUKHI,
  G_UNICODE_SCRIPT_HAN,
  G_UNICODE_SCRIPT_HANGUL,
  G_UNICODE_SCRIPT_HEBREW,
  G_UNICODE_SCRIPT_HIRAGANA,
  G_UNICODE_SCRIPT_KANNADA,
  G_UNICODE_SCRIPT_KATAKANA,
  G_UNICODE_SCRIPT_KHMER,
  G_UNICODE_SCRIPT_LAO,
  G_UNICODE_SCRIPT_LATIN,
  G_UNICODE_SCRIPT_MALAYALAM,
  G_UNICODE_SCRIPT_MONGOLIAN,
  G_UNICODE_SCRIPT_MYANMAR,
  G_UNICODE_SCRIPT_OGHAM,
  G_UNICODE_SCRIPT_OLD_ITALIC,
  G_UNICODE_SCRIPT_ORIYA,
  G_UNICODE_SCRIPT_RUNIC,
  G_UNICODE_SCRIPT_SINHALA,
  G_UNICODE_SCRIPT_SYRIAC,
  G_UNICODE_SCRIPT_TAMIL,
  G_UNICODE_SCRIPT_TELUGU,
  G_UNICODE_SCRIPT_THAANA,
  G_UNICODE_SCRIPT_THAI,
  G_UNICODE_SCRIPT_TIBETAN,
  G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
  G_UNICODE_SCRIPT_YI,
  G_UNICODE_SCRIPT_TAGALOG,
  G_UNICODE_SCRIPT_HANUNOO,
  G_UNICODE_SCRIPT_BUHID,
  G_UNICODE_SCRIPT_TAGBANWA,


  G_UNICODE_SCRIPT_BRAILLE,
  G_UNICODE_SCRIPT_CYPRIOT,
  G_UNICODE_SCRIPT_LIMBU,
  G_UNICODE_SCRIPT_OSMANYA,
  G_UNICODE_SCRIPT_SHAVIAN,
  G_UNICODE_SCRIPT_LINEAR_B,
  G_UNICODE_SCRIPT_TAI_LE,
  G_UNICODE_SCRIPT_UGARITIC,


  G_UNICODE_SCRIPT_NEW_TAI_LUE,
  G_UNICODE_SCRIPT_BUGINESE,
  G_UNICODE_SCRIPT_GLAGOLITIC,
  G_UNICODE_SCRIPT_TIFINAGH,
  G_UNICODE_SCRIPT_SYLOTI_NAGRI,
  G_UNICODE_SCRIPT_OLD_PERSIAN,
  G_UNICODE_SCRIPT_KHAROSHTHI,


  G_UNICODE_SCRIPT_UNKNOWN,
  G_UNICODE_SCRIPT_BALINESE,
  G_UNICODE_SCRIPT_CUNEIFORM,
  G_UNICODE_SCRIPT_PHOENICIAN,
  G_UNICODE_SCRIPT_PHAGS_PA,
  G_UNICODE_SCRIPT_NKO,


  G_UNICODE_SCRIPT_KAYAH_LI,
  G_UNICODE_SCRIPT_LEPCHA,
  G_UNICODE_SCRIPT_REJANG,
  G_UNICODE_SCRIPT_SUNDANESE,
  G_UNICODE_SCRIPT_SAURASHTRA,
  G_UNICODE_SCRIPT_CHAM,
  G_UNICODE_SCRIPT_OL_CHIKI,
  G_UNICODE_SCRIPT_VAI,
  G_UNICODE_SCRIPT_CARIAN,
  G_UNICODE_SCRIPT_LYCIAN,
  G_UNICODE_SCRIPT_LYDIAN,


  G_UNICODE_SCRIPT_AVESTAN,
  G_UNICODE_SCRIPT_BAMUM,
  G_UNICODE_SCRIPT_EGYPTIAN_HIEROGLYPHS,
  G_UNICODE_SCRIPT_IMPERIAL_ARAMAIC,
  G_UNICODE_SCRIPT_INSCRIPTIONAL_PAHLAVI,
  G_UNICODE_SCRIPT_INSCRIPTIONAL_PARTHIAN,
  G_UNICODE_SCRIPT_JAVANESE,
  G_UNICODE_SCRIPT_KAITHI,
  G_UNICODE_SCRIPT_LISU,
  G_UNICODE_SCRIPT_MEETEI_MAYEK,
  G_UNICODE_SCRIPT_OLD_SOUTH_ARABIAN,
  G_UNICODE_SCRIPT_OLD_TURKIC,
  G_UNICODE_SCRIPT_SAMARITAN,
  G_UNICODE_SCRIPT_TAI_THAM,
  G_UNICODE_SCRIPT_TAI_VIET,


  G_UNICODE_SCRIPT_BATAK,
  G_UNICODE_SCRIPT_BRAHMI,
  G_UNICODE_SCRIPT_MANDAIC,


  G_UNICODE_SCRIPT_CHAKMA,
  G_UNICODE_SCRIPT_MEROITIC_CURSIVE,
  G_UNICODE_SCRIPT_MEROITIC_HIEROGLYPHS,
  G_UNICODE_SCRIPT_MIAO,
  G_UNICODE_SCRIPT_SHARADA,
  G_UNICODE_SCRIPT_SORA_SOMPENG,
  G_UNICODE_SCRIPT_TAKRI
} GUnicodeScript;

guint32 g_unicode_script_to_iso15924 (GUnicodeScript script);
GUnicodeScript g_unicode_script_from_iso15924 (guint32 iso15924);



gboolean g_unichar_isalnum (gunichar c) __attribute__((__const__));
gboolean g_unichar_isalpha (gunichar c) __attribute__((__const__));
gboolean g_unichar_iscntrl (gunichar c) __attribute__((__const__));
gboolean g_unichar_isdigit (gunichar c) __attribute__((__const__));
gboolean g_unichar_isgraph (gunichar c) __attribute__((__const__));
gboolean g_unichar_islower (gunichar c) __attribute__((__const__));
gboolean g_unichar_isprint (gunichar c) __attribute__((__const__));
gboolean g_unichar_ispunct (gunichar c) __attribute__((__const__));
gboolean g_unichar_isspace (gunichar c) __attribute__((__const__));
gboolean g_unichar_isupper (gunichar c) __attribute__((__const__));
gboolean g_unichar_isxdigit (gunichar c) __attribute__((__const__));
gboolean g_unichar_istitle (gunichar c) __attribute__((__const__));
gboolean g_unichar_isdefined (gunichar c) __attribute__((__const__));
gboolean g_unichar_iswide (gunichar c) __attribute__((__const__));
gboolean g_unichar_iswide_cjk(gunichar c) __attribute__((__const__));
gboolean g_unichar_iszerowidth(gunichar c) __attribute__((__const__));
gboolean g_unichar_ismark (gunichar c) __attribute__((__const__));



gunichar g_unichar_toupper (gunichar c) __attribute__((__const__));
gunichar g_unichar_tolower (gunichar c) __attribute__((__const__));
gunichar g_unichar_totitle (gunichar c) __attribute__((__const__));



gint g_unichar_digit_value (gunichar c) __attribute__((__const__));

gint g_unichar_xdigit_value (gunichar c) __attribute__((__const__));


GUnicodeType g_unichar_type (gunichar c) __attribute__((__const__));


GUnicodeBreakType g_unichar_break_type (gunichar c) __attribute__((__const__));


gint g_unichar_combining_class (gunichar uc) __attribute__((__const__));

gboolean g_unichar_get_mirror_char (gunichar ch,
                                    gunichar *mirrored_ch);

GUnicodeScript g_unichar_get_script (gunichar ch) __attribute__((__const__));


gboolean g_unichar_validate (gunichar ch) __attribute__((__const__));


gboolean g_unichar_compose (gunichar a,
                            gunichar b,
                            gunichar *ch);
gboolean g_unichar_decompose (gunichar ch,
                              gunichar *a,
                              gunichar *b);

gsize g_unichar_fully_decompose (gunichar ch,
                                 gboolean compat,
                                 gunichar *result,
                                 gsize result_len);
# 589 "../glib/gunicode.h"
void g_unicode_canonical_ordering (gunichar *string,
                                   gsize len);


__attribute__((__deprecated__))
gunichar *g_unicode_canonical_decomposition (gunichar ch,
                                             gsize *result_len) __attribute__((__malloc__));



extern const gchar * const g_utf8_skip;
# 614 "../glib/gunicode.h"
gunichar g_utf8_get_char (const gchar *p) __attribute__((__pure__));
gunichar g_utf8_get_char_validated (const gchar *p,
                                    gssize max_len) __attribute__((__pure__));

gchar* g_utf8_offset_to_pointer (const gchar *str,
                                   glong offset) __attribute__((__pure__));
glong g_utf8_pointer_to_offset (const gchar *str,
                                   const gchar *pos) __attribute__((__pure__));
gchar* g_utf8_prev_char (const gchar *p) __attribute__((__pure__));
gchar* g_utf8_find_next_char (const gchar *p,
                                   const gchar *end) __attribute__((__pure__));
gchar* g_utf8_find_prev_char (const gchar *str,
                                   const gchar *p) __attribute__((__pure__));

glong g_utf8_strlen (const gchar *p,
                                   gssize max) __attribute__((__pure__));


gchar *g_utf8_substring (const gchar *str,
                                   glong start_pos,
                                   glong end_pos) __attribute__((__malloc__));

gchar *g_utf8_strncpy (gchar *dest,
                                   const gchar *src,
                                   gsize n);



gchar* g_utf8_strchr (const gchar *p,
                       gssize len,
                       gunichar c);
gchar* g_utf8_strrchr (const gchar *p,
                       gssize len,
                       gunichar c);
gchar* g_utf8_strreverse (const gchar *str,
                          gssize len);

gunichar2 *g_utf8_to_utf16 (const gchar *str,
                                glong len,
                                glong *items_read,
                                glong *items_written,
                                GError **error) __attribute__((__malloc__));
gunichar * g_utf8_to_ucs4 (const gchar *str,
                                glong len,
                                glong *items_read,
                                glong *items_written,
                                GError **error) __attribute__((__malloc__));
gunichar * g_utf8_to_ucs4_fast (const gchar *str,
                                glong len,
                                glong *items_written) __attribute__((__malloc__));
gunichar * g_utf16_to_ucs4 (const gunichar2 *str,
                                glong len,
                                glong *items_read,
                                glong *items_written,
                                GError **error) __attribute__((__malloc__));
gchar* g_utf16_to_utf8 (const gunichar2 *str,
                                glong len,
                                glong *items_read,
                                glong *items_written,
                                GError **error) __attribute__((__malloc__));
gunichar2 *g_ucs4_to_utf16 (const gunichar *str,
                                glong len,
                                glong *items_read,
                                glong *items_written,
                                GError **error) __attribute__((__malloc__));
gchar* g_ucs4_to_utf8 (const gunichar *str,
                                glong len,
                                glong *items_read,
                                glong *items_written,
                                GError **error) __attribute__((__malloc__));

gint g_unichar_to_utf8 (gunichar c,
                             gchar *outbuf);

gboolean g_utf8_validate (const gchar *str,
                          gssize max_len,
                          const gchar **end);

gchar *g_utf8_strup (const gchar *str,
                       gssize len) __attribute__((__malloc__));
gchar *g_utf8_strdown (const gchar *str,
                       gssize len) __attribute__((__malloc__));
gchar *g_utf8_casefold (const gchar *str,
                        gssize len) __attribute__((__malloc__));
# 723 "../glib/gunicode.h"
typedef enum {
  G_NORMALIZE_DEFAULT,
  G_NORMALIZE_NFD = G_NORMALIZE_DEFAULT,
  G_NORMALIZE_DEFAULT_COMPOSE,
  G_NORMALIZE_NFC = G_NORMALIZE_DEFAULT_COMPOSE,
  G_NORMALIZE_ALL,
  G_NORMALIZE_NFKD = G_NORMALIZE_ALL,
  G_NORMALIZE_ALL_COMPOSE,
  G_NORMALIZE_NFKC = G_NORMALIZE_ALL_COMPOSE
} GNormalizeMode;

gchar *g_utf8_normalize (const gchar *str,
                         gssize len,
                         GNormalizeMode mode) __attribute__((__malloc__));

gint g_utf8_collate (const gchar *str1,
                           const gchar *str2) __attribute__((__pure__));
gchar *g_utf8_collate_key (const gchar *str,
                           gssize len) __attribute__((__malloc__));
gchar *g_utf8_collate_key_for_filename (const gchar *str,
                                        gssize len) __attribute__((__malloc__));




gchar *_g_utf8_make_valid (const gchar *name);


# 36 "../glib/gstring.h" 2
# 1 "../glib/gutils.h" 1
# 34 "../glib/gutils.h"
# 1 "../glib/gtypes.h" 1
# 35 "../glib/gutils.h" 2



# 96 "../glib/gutils.h"
const gchar * g_get_user_name (void);
const gchar * g_get_real_name (void);
const gchar * g_get_home_dir (void);
const gchar * g_get_tmp_dir (void);
const gchar * g_get_host_name (void);
gchar * g_get_prgname (void);
void g_set_prgname (const gchar *prgname);
const gchar * g_get_application_name (void);
void g_set_application_name (const gchar *application_name);

void g_reload_user_special_dirs_cache (void);
const gchar * g_get_user_data_dir (void);
const gchar * g_get_user_config_dir (void);
const gchar * g_get_user_cache_dir (void);
const gchar * const * g_get_system_data_dirs (void);
# 130 "../glib/gutils.h"
const gchar * const * g_get_system_config_dirs (void);

const gchar * g_get_user_runtime_dir (void);
# 156 "../glib/gutils.h"
typedef enum {
  G_USER_DIRECTORY_DESKTOP,
  G_USER_DIRECTORY_DOCUMENTS,
  G_USER_DIRECTORY_DOWNLOAD,
  G_USER_DIRECTORY_MUSIC,
  G_USER_DIRECTORY_PICTURES,
  G_USER_DIRECTORY_PUBLIC_SHARE,
  G_USER_DIRECTORY_TEMPLATES,
  G_USER_DIRECTORY_VIDEOS,

  G_USER_N_DIRECTORIES
} GUserDirectory;

const gchar * g_get_user_special_dir (GUserDirectory directory);
# 179 "../glib/gutils.h"
typedef struct _GDebugKey GDebugKey;
struct _GDebugKey
{
  const gchar *key;
  guint value;
};



guint g_parse_debug_string (const gchar *string,
         const GDebugKey *keys,
         guint nkeys);

gint g_snprintf (gchar *string,
         gulong n,
         gchar const *format,
         ...) __attribute__((__format__ (__printf__, 3, 4)));
gint g_vsnprintf (gchar *string,
         gulong n,
         gchar const *format,
         va_list args);

void g_nullify_pointer (gpointer *nullify_location);

typedef enum
{
  G_FORMAT_SIZE_DEFAULT = 0,
  G_FORMAT_SIZE_LONG_FORMAT = 1 << 0,
  G_FORMAT_SIZE_IEC_UNITS = 1 << 1
} GFormatSizeFlags;


gchar *g_format_size_full (guint64 size,
                             GFormatSizeFlags flags);

gchar *g_format_size (guint64 size);

__attribute__((__deprecated__))
gchar *g_format_size_for_display (goffset size);
# 227 "../glib/gutils.h"
typedef void (*GVoidFunc) (void);
# 238 "../glib/gutils.h"
__attribute__((__deprecated__))
void g_atexit (GVoidFunc func);
# 263 "../glib/gutils.h"
gchar* g_find_program_in_path (const gchar *program);



static __inline __attribute__ ((unused)) gint g_bit_nth_lsf (gulong mask,
           gint nth_bit) __attribute__((__const__));
static __inline __attribute__ ((unused)) gint g_bit_nth_msf (gulong mask,
           gint nth_bit) __attribute__((__const__));
static __inline __attribute__ ((unused)) guint g_bit_storage (gulong number) __attribute__((__const__));




static __inline __attribute__ ((unused)) gint
g_bit_nth_lsf (gulong mask,
        gint nth_bit)
{
  if ((__builtin_expect (__extension__ ({ int _g_boolean_var_; if (nth_bit < -1) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 0)))
    nth_bit = -1;
  while (nth_bit < ((8 * 8) - 1))
    {
      nth_bit++;
      if (mask & (1UL << nth_bit))
 return nth_bit;
    }
  return -1;
}
static __inline __attribute__ ((unused)) gint
g_bit_nth_msf (gulong mask,
        gint nth_bit)
{
  if (nth_bit < 0 || (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (nth_bit > 8 * 8) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 0)))
    nth_bit = 8 * 8;
  while (nth_bit > 0)
    {
      nth_bit--;
      if (mask & (1UL << nth_bit))
 return nth_bit;
    }
  return -1;
}
static __inline __attribute__ ((unused)) guint
g_bit_storage (gulong number)
{

  return (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (number) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) ?
    ((8 * 8U - 1) ^ (guint) __builtin_clzl(number)) + 1 : 1;
# 321 "../glib/gutils.h"
}



# 37 "../glib/gstring.h" 2



typedef struct _GString GString;

struct _GString
{
  gchar *str;
  gsize len;
  gsize allocated_len;
};

GString* g_string_new (const gchar *init);
GString* g_string_new_len (const gchar *init,
                                         gssize len);
GString* g_string_sized_new (gsize dfl_size);
gchar* g_string_free (GString *string,
                                         gboolean free_segment);
gboolean g_string_equal (const GString *v,
                                         const GString *v2);
guint g_string_hash (const GString *str);
GString* g_string_assign (GString *string,
                                         const gchar *rval);
GString* g_string_truncate (GString *string,
                                         gsize len);
GString* g_string_set_size (GString *string,
                                         gsize len);
GString* g_string_insert_len (GString *string,
                                         gssize pos,
                                         const gchar *val,
                                         gssize len);
GString* g_string_append (GString *string,
                                         const gchar *val);
GString* g_string_append_len (GString *string,
                                         const gchar *val,
                                         gssize len);
GString* g_string_append_c (GString *string,
                                         gchar c);
GString* g_string_append_unichar (GString *string,
                                         gunichar wc);
GString* g_string_prepend (GString *string,
                                         const gchar *val);
GString* g_string_prepend_c (GString *string,
                                         gchar c);
GString* g_string_prepend_unichar (GString *string,
                                         gunichar wc);
GString* g_string_prepend_len (GString *string,
                                         const gchar *val,
                                         gssize len);
GString* g_string_insert (GString *string,
                                         gssize pos,
                                         const gchar *val);
GString* g_string_insert_c (GString *string,
                                         gssize pos,
                                         gchar c);
GString* g_string_insert_unichar (GString *string,
                                         gssize pos,
                                         gunichar wc);
GString* g_string_overwrite (GString *string,
                                         gsize pos,
                                         const gchar *val);
GString* g_string_overwrite_len (GString *string,
                                         gsize pos,
                                         const gchar *val,
                                         gssize len);
GString* g_string_erase (GString *string,
                                         gssize pos,
                                         gssize len);
GString* g_string_ascii_down (GString *string);
GString* g_string_ascii_up (GString *string);
void g_string_vprintf (GString *string,
                                         const gchar *format,
                                         va_list args);
void g_string_printf (GString *string,
                                         const gchar *format,
                                         ...) __attribute__((__format__ (__printf__, 2, 3)));
void g_string_append_vprintf (GString *string,
                                         const gchar *format,
                                         va_list args);
void g_string_append_printf (GString *string,
                                         const gchar *format,
                                         ...) __attribute__((__format__ (__printf__, 2, 3)));
GString* g_string_append_uri_escaped (GString *string,
                                          const gchar *unescaped,
                                          const gchar *reserved_chars_allowed,
                                          gboolean allow_utf8);



static inline GString*
g_string_append_c_inline (GString *gstring,
                          gchar c)
{
  if (gstring->len + 1 < gstring->allocated_len)
    {
      gstring->str[gstring->len++] = c;
      gstring->str[gstring->len] = 0;
    }
  else
    g_string_insert_c (gstring, -1, c);
  return gstring;
}




__attribute__((__deprecated__))
GString *g_string_down (GString *string);
__attribute__((__deprecated__))
GString *g_string_up (GString *string);







# 30 "gtestutils.h" 2
# 1 "../glib/gerror.h" 1
# 31 "gtestutils.h" 2
# 1 "../glib/gslist.h" 1
# 34 "../glib/gslist.h"
# 1 "../glib/gmem.h" 1
# 35 "../glib/gslist.h" 2



typedef struct _GSList GSList;

struct _GSList
{
  gpointer data;
  GSList *next;
};



GSList* g_slist_alloc (void) __attribute__((warn_unused_result));
void g_slist_free (GSList *list);
void g_slist_free_1 (GSList *list);

void g_slist_free_full (GSList *list,
       GDestroyNotify free_func);
GSList* g_slist_append (GSList *list,
       gpointer data) __attribute__((warn_unused_result));
GSList* g_slist_prepend (GSList *list,
       gpointer data) __attribute__((warn_unused_result));
GSList* g_slist_insert (GSList *list,
       gpointer data,
       gint position) __attribute__((warn_unused_result));
GSList* g_slist_insert_sorted (GSList *list,
       gpointer data,
       GCompareFunc func) __attribute__((warn_unused_result));
GSList* g_slist_insert_sorted_with_data (GSList *list,
       gpointer data,
       GCompareDataFunc func,
       gpointer user_data) __attribute__((warn_unused_result));
GSList* g_slist_insert_before (GSList *slist,
       GSList *sibling,
       gpointer data) __attribute__((warn_unused_result));
GSList* g_slist_concat (GSList *list1,
       GSList *list2) __attribute__((warn_unused_result));
GSList* g_slist_remove (GSList *list,
       gconstpointer data) __attribute__((warn_unused_result));
GSList* g_slist_remove_all (GSList *list,
       gconstpointer data) __attribute__((warn_unused_result));
GSList* g_slist_remove_link (GSList *list,
       GSList *link_) __attribute__((warn_unused_result));
GSList* g_slist_delete_link (GSList *list,
       GSList *link_) __attribute__((warn_unused_result));
GSList* g_slist_reverse (GSList *list) __attribute__((warn_unused_result));
GSList* g_slist_copy (GSList *list) __attribute__((warn_unused_result));
GSList* g_slist_nth (GSList *list,
       guint n);
GSList* g_slist_find (GSList *list,
       gconstpointer data);
GSList* g_slist_find_custom (GSList *list,
       gconstpointer data,
       GCompareFunc func);
gint g_slist_position (GSList *list,
       GSList *llink);
gint g_slist_index (GSList *list,
       gconstpointer data);
GSList* g_slist_last (GSList *list);
guint g_slist_length (GSList *list);
void g_slist_foreach (GSList *list,
       GFunc func,
       gpointer user_data);
GSList* g_slist_sort (GSList *list,
       GCompareFunc compare_func) __attribute__((warn_unused_result));
GSList* g_slist_sort_with_data (GSList *list,
       GCompareDataFunc compare_func,
       gpointer user_data) __attribute__((warn_unused_result));
gpointer g_slist_nth_data (GSList *list,
       guint n);




# 32 "gtestutils.h" 2



typedef struct GTestCase GTestCase;
typedef struct GTestSuite GTestSuite;
typedef void (*GTestFunc) (void);
typedef void (*GTestDataFunc) (gconstpointer user_data);
typedef void (*GTestFixtureFunc) (gpointer fixture,
                                  gconstpointer user_data);
# 79 "gtestutils.h"
int g_strcmp0 (const char *str1,
                                         const char *str2);


void g_test_minimized_result (double minimized_quantity,
                                         const char *format,
                                         ...) __attribute__((__format__ (__printf__, 2, 3)));
void g_test_maximized_result (double maximized_quantity,
                                         const char *format,
                                         ...) __attribute__((__format__ (__printf__, 2, 3)));


void g_test_init (int *argc,
                                         char ***argv,
                                         ...);
# 103 "gtestutils.h"
int g_test_run (void);

void g_test_add_func (const char *testpath,
                                         GTestFunc test_func);

void g_test_add_data_func (const char *testpath,
                                         gconstpointer test_data,
                                         GTestDataFunc test_func);

void g_test_fail (void);
# 128 "gtestutils.h"
void g_test_message (const char *format,
                                         ...) __attribute__((__format__ (__printf__, 1, 2)));
void g_test_bug_base (const char *uri_pattern);
void g_test_bug (const char *bug_uri_snippet);

void g_test_timer_start (void);
double g_test_timer_elapsed (void);
double g_test_timer_last (void);


void g_test_queue_free (gpointer gfree_pointer);
void g_test_queue_destroy (GDestroyNotify destroy_func,
                                         gpointer destroy_data);



typedef enum {
  G_TEST_TRAP_SILENCE_STDOUT = 1 << 7,
  G_TEST_TRAP_SILENCE_STDERR = 1 << 8,
  G_TEST_TRAP_INHERIT_STDIN = 1 << 9
} GTestTrapFlags;
gboolean g_test_trap_fork (guint64 usec_timeout,
                                         GTestTrapFlags test_trap_flags);
gboolean g_test_trap_has_passed (void);
gboolean g_test_trap_reached_timeout (void);
# 162 "gtestutils.h"
gint32 g_test_rand_int (void);
gint32 g_test_rand_int_range (gint32 begin,
                                         gint32 end);
double g_test_rand_double (void);
double g_test_rand_double_range (double range_start,
                                         double range_end);


GTestCase* g_test_create_case (const char *test_name,
                                         gsize data_size,
                                         gconstpointer test_data,
                                         GTestFixtureFunc data_setup,
                                         GTestFixtureFunc data_test,
                                         GTestFixtureFunc data_teardown);
GTestSuite* g_test_create_suite (const char *suite_name);
GTestSuite* g_test_get_root (void);
void g_test_suite_add (GTestSuite *suite,
                                         GTestCase *test_case);
void g_test_suite_add_suite (GTestSuite *suite,
                                         GTestSuite *nestedsuite);
int g_test_run_suite (GTestSuite *suite);


void g_test_trap_assertions (const char *domain,
                                         const char *file,
                                         int line,
                                         const char *func,
                                         guint64 assertion_flags,
                                         const char *pattern);
void g_assertion_message (const char *domain,
                                         const char *file,
                                         int line,
                                         const char *func,
                                         const char *message) __attribute__((__noreturn__));
void g_assertion_message_expr (const char *domain,
                                         const char *file,
                                         int line,
                                         const char *func,
                                         const char *expr) __attribute__((__noreturn__));
void g_assertion_message_cmpstr (const char *domain,
                                         const char *file,
                                         int line,
                                         const char *func,
                                         const char *expr,
                                         const char *arg1,
                                         const char *cmp,
                                         const char *arg2) __attribute__((__noreturn__));
void g_assertion_message_cmpnum (const char *domain,
                                         const char *file,
                                         int line,
                                         const char *func,
                                         const char *expr,
                                         long double arg1,
                                         const char *cmp,
                                         long double arg2,
                                         char numtype) __attribute__((__noreturn__));
void g_assertion_message_error (const char *domain,
                                         const char *file,
                                         int line,
                                         const char *func,
                                         const char *expr,
                                         const GError *error,
                                         GQuark error_domain,
                                         int error_code) __attribute__((__noreturn__));
void g_test_add_vtable (const char *testpath,
                                         gsize data_size,
                                         gconstpointer test_data,
                                         GTestFixtureFunc data_setup,
                                         GTestFixtureFunc data_test,
                                         GTestFixtureFunc data_teardown);
typedef struct {
  gboolean test_initialized;
  gboolean test_quick;
  gboolean test_perf;
  gboolean test_verbose;
  gboolean test_quiet;
  gboolean test_undefined;
} GTestConfig;
extern const GTestConfig * const g_test_config_vars;


typedef enum {
  G_TEST_LOG_NONE,
  G_TEST_LOG_ERROR,
  G_TEST_LOG_START_BINARY,
  G_TEST_LOG_LIST_CASE,
  G_TEST_LOG_SKIP_CASE,
  G_TEST_LOG_START_CASE,
  G_TEST_LOG_STOP_CASE,
  G_TEST_LOG_MIN_RESULT,
  G_TEST_LOG_MAX_RESULT,
  G_TEST_LOG_MESSAGE
} GTestLogType;

typedef struct {
  GTestLogType log_type;
  guint n_strings;
  gchar **strings;
  guint n_nums;
  long double *nums;
} GTestLogMsg;
typedef struct {

  GString *data;
  GSList *msgs;
} GTestLogBuffer;

const char* g_test_log_type_name (GTestLogType log_type);
GTestLogBuffer* g_test_log_buffer_new (void);
void g_test_log_buffer_free (GTestLogBuffer *tbuffer);
void g_test_log_buffer_push (GTestLogBuffer *tbuffer,
                                         guint n_bytes,
                                         const guint8 *bytes);
GTestLogMsg* g_test_log_buffer_pop (GTestLogBuffer *tbuffer);
void g_test_log_msg_free (GTestLogMsg *tmsg);
# 291 "gtestutils.h"
typedef gboolean (*GTestLogFatalFunc) (const gchar *log_domain,
                                                 GLogLevelFlags log_level,
                                                 const gchar *message,
                                                 gpointer user_data);
void
g_test_log_set_fatal_handler (GTestLogFatalFunc log_func,
                                         gpointer user_data);


# 41 "gnode.c" 2
# 108 "gnode.c"
GNode*
g_node_new (gpointer data)
{
  GNode *node = ((GNode*) g_slice_alloc0 (sizeof (GNode)));
  node->data = data;
  return node;
}

static void
g_nodes_free (GNode *node)
{
  while (node)
    {
      GNode *next = node->next;
      if (node->children)
        g_nodes_free (node->children);
      do { if (1) g_slice_free1 (sizeof (GNode), (node)); else (void) ((GNode*) 0 == (node)); } while (0);
      node = next;
    }
}
# 136 "gnode.c"
void
g_node_destroy (GNode *root)
{
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (root != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "root != NULL"); return; }; }while (0);

  if (!(((GNode*) (root))->parent == ((void *)0) && ((GNode*) (root))->prev == ((void *)0) && ((GNode*) (root))->next == ((void *)0)))
    g_node_unlink (root);

  g_nodes_free (root);
}







void
g_node_unlink (GNode *node)
{
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (node != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "node != NULL"); return; }; }while (0);

  if (node->prev)
    node->prev->next = node->next;
  else if (node->parent)
    node->parent->children = node->next;
  node->parent = ((void *)0);
  if (node->next)
    {
      node->next->prev = node->prev;
      node->next = ((void *)0);
    }
  node->prev = ((void *)0);
}
# 184 "gnode.c"
GNode*
g_node_copy_deep (GNode *node,
    GCopyFunc copy_func,
    gpointer data)
{
  GNode *new_node = ((void *)0);

  if (copy_func == ((void *)0))
 return g_node_copy (node);

  if (node)
    {
      GNode *child, *new_child;

      new_node = g_node_new (copy_func (node->data, data));

      for (child = g_node_last_child (node); child; child = child->prev)
 {
   new_child = g_node_copy_deep (child, copy_func, data);
   g_node_prepend (new_node, new_child);
 }
    }

  return new_node;
}
# 219 "gnode.c"
GNode*
g_node_copy (GNode *node)
{
  GNode *new_node = ((void *)0);

  if (node)
    {
      GNode *child;

      new_node = g_node_new (node->data);

      for (child = g_node_last_child (node); child; child = child->prev)
 g_node_prepend (new_node, g_node_copy (child));
    }

  return new_node;
}
# 248 "gnode.c"
GNode*
g_node_insert (GNode *parent,
        gint position,
        GNode *node)
{
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (parent != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "parent != NULL"); return (node); }; }while (0);
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (node != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "node != NULL"); return (node); }; }while (0);
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if ((((GNode*) (node))->parent == ((void *)0) && ((GNode*) (node))->prev == ((void *)0) && ((GNode*) (node))->next == ((void *)0))) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "G_NODE_IS_ROOT (node)"); return (node); }; }while (0);

  if (position > 0)
    return g_node_insert_before (parent,
     g_node_nth_child (parent, position),
     node);
  else if (position == 0)
    return g_node_prepend (parent, node);
  else
    return g_node_insert_before ((parent), ((void *)0), (node));
}
# 278 "gnode.c"
GNode*
g_node_insert_before (GNode *parent,
        GNode *sibling,
        GNode *node)
{
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (parent != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "parent != NULL"); return (node); }; }while (0);
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (node != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "node != NULL"); return (node); }; }while (0);
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if ((((GNode*) (node))->parent == ((void *)0) && ((GNode*) (node))->prev == ((void *)0) && ((GNode*) (node))->next == ((void *)0))) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "G_NODE_IS_ROOT (node)"); return (node); }; }while (0);
  if (sibling)
    do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (sibling->parent == parent) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "sibling->parent == parent"); return (node); }; }while (0);

  node->parent = parent;

  if (sibling)
    {
      if (sibling->prev)
 {
   node->prev = sibling->prev;
   node->prev->next = node;
   node->next = sibling;
   sibling->prev = node;
 }
      else
 {
   node->parent->children = node;
   node->next = sibling;
   sibling->prev = node;
 }
    }
  else
    {
      if (parent->children)
 {
   sibling = parent->children;
   while (sibling->next)
     sibling = sibling->next;
   node->prev = sibling;
   sibling->next = node;
 }
      else
 node->parent->children = node;
    }

  return node;
}
# 335 "gnode.c"
GNode*
g_node_insert_after (GNode *parent,
       GNode *sibling,
       GNode *node)
{
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (parent != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "parent != NULL"); return (node); }; }while (0);
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (node != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "node != NULL"); return (node); }; }while (0);
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if ((((GNode*) (node))->parent == ((void *)0) && ((GNode*) (node))->prev == ((void *)0) && ((GNode*) (node))->next == ((void *)0))) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "G_NODE_IS_ROOT (node)"); return (node); }; }while (0);
  if (sibling)
    do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (sibling->parent == parent) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "sibling->parent == parent"); return (node); }; }while (0);

  node->parent = parent;

  if (sibling)
    {
      if (sibling->next)
 {
   sibling->next->prev = node;
 }
      node->next = sibling->next;
      node->prev = sibling;
      sibling->next = node;
    }
  else
    {
      if (parent->children)
 {
   node->next = parent->children;
   parent->children->prev = node;
 }
      parent->children = node;
    }

  return node;
}
# 380 "gnode.c"
GNode*
g_node_prepend (GNode *parent,
  GNode *node)
{
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (parent != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "parent != NULL"); return (node); }; }while (0);

  return g_node_insert_before (parent, parent->children, node);
}
# 397 "gnode.c"
GNode*
g_node_get_root (GNode *node)
{
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (node != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "node != NULL"); return (((void *)0)); }; }while (0);

  while (node->parent)
    node = node->parent;

  return node;
}
# 419 "gnode.c"
gboolean
g_node_is_ancestor (GNode *node,
      GNode *descendant)
{
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (node != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "node != NULL"); return ((0)); }; }while (0);
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (descendant != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "descendant != NULL"); return ((0)); }; }while (0);

  while (descendant)
    {
      if (descendant->parent == node)
 return (!(0));

      descendant = descendant->parent;
    }

  return (0);
}
# 448 "gnode.c"
guint
g_node_depth (GNode *node)
{
  guint depth = 0;

  while (node)
    {
      depth++;
      node = node->parent;
    }

  return depth;
}
# 469 "gnode.c"
void
g_node_reverse_children (GNode *node)
{
  GNode *child;
  GNode *last;

  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (node != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "node != NULL"); return; }; }while (0);

  child = node->children;
  last = ((void *)0);
  while (child)
    {
      last = child;
      child = last->next;
      last->next = last->prev;
      last->prev = child;
    }
  node->children = last;
}
# 501 "gnode.c"
guint
g_node_max_height (GNode *root)
{
  GNode *child;
  guint max_height = 0;

  if (!root)
    return 0;

  child = root->children;
  while (child)
    {
      guint tmp_height;

      tmp_height = g_node_max_height (child);
      if (tmp_height > max_height)
 max_height = tmp_height;
      child = child->next;
    }

  return max_height + 1;
}

static gboolean
g_node_traverse_pre_order (GNode *node,
      GTraverseFlags flags,
      GNodeTraverseFunc func,
      gpointer data)
{
  if (node->children)
    {
      GNode *child;

      if ((flags & G_TRAVERSE_NON_LEAFS) &&
   func (node, data))
 return (!(0));

      child = node->children;
      while (child)
 {
   GNode *current;

   current = child;
   child = current->next;
   if (g_node_traverse_pre_order (current, flags, func, data))
     return (!(0));
 }
    }
  else if ((flags & G_TRAVERSE_LEAFS) &&
    func (node, data))
    return (!(0));

  return (0);
}

static gboolean
g_node_depth_traverse_pre_order (GNode *node,
     GTraverseFlags flags,
     guint depth,
     GNodeTraverseFunc func,
     gpointer data)
{
  if (node->children)
    {
      GNode *child;

      if ((flags & G_TRAVERSE_NON_LEAFS) &&
   func (node, data))
 return (!(0));

      depth--;
      if (!depth)
 return (0);

      child = node->children;
      while (child)
 {
   GNode *current;

   current = child;
   child = current->next;
   if (g_node_depth_traverse_pre_order (current, flags, depth, func, data))
     return (!(0));
 }
    }
  else if ((flags & G_TRAVERSE_LEAFS) &&
    func (node, data))
    return (!(0));

  return (0);
}

static gboolean
g_node_traverse_post_order (GNode *node,
       GTraverseFlags flags,
       GNodeTraverseFunc func,
       gpointer data)
{
  if (node->children)
    {
      GNode *child;

      child = node->children;
      while (child)
 {
   GNode *current;

   current = child;
   child = current->next;
   if (g_node_traverse_post_order (current, flags, func, data))
     return (!(0));
 }

      if ((flags & G_TRAVERSE_NON_LEAFS) &&
   func (node, data))
 return (!(0));

    }
  else if ((flags & G_TRAVERSE_LEAFS) &&
    func (node, data))
    return (!(0));

  return (0);
}

static gboolean
g_node_depth_traverse_post_order (GNode *node,
      GTraverseFlags flags,
      guint depth,
      GNodeTraverseFunc func,
      gpointer data)
{
  if (node->children)
    {
      depth--;
      if (depth)
 {
   GNode *child;

   child = node->children;
   while (child)
     {
       GNode *current;

       current = child;
       child = current->next;
       if (g_node_depth_traverse_post_order (current, flags, depth, func, data))
  return (!(0));
     }
 }

      if ((flags & G_TRAVERSE_NON_LEAFS) &&
   func (node, data))
 return (!(0));

    }
  else if ((flags & G_TRAVERSE_LEAFS) &&
    func (node, data))
    return (!(0));

  return (0);
}

static gboolean
g_node_traverse_in_order (GNode *node,
     GTraverseFlags flags,
     GNodeTraverseFunc func,
     gpointer data)
{
  if (node->children)
    {
      GNode *child;
      GNode *current;

      child = node->children;
      current = child;
      child = current->next;

      if (g_node_traverse_in_order (current, flags, func, data))
 return (!(0));

      if ((flags & G_TRAVERSE_NON_LEAFS) &&
   func (node, data))
 return (!(0));

      while (child)
 {
   current = child;
   child = current->next;
   if (g_node_traverse_in_order (current, flags, func, data))
     return (!(0));
 }
    }
  else if ((flags & G_TRAVERSE_LEAFS) &&
    func (node, data))
    return (!(0));

  return (0);
}

static gboolean
g_node_depth_traverse_in_order (GNode *node,
    GTraverseFlags flags,
    guint depth,
    GNodeTraverseFunc func,
    gpointer data)
{
  if (node->children)
    {
      depth--;
      if (depth)
 {
   GNode *child;
   GNode *current;

   child = node->children;
   current = child;
   child = current->next;

   if (g_node_depth_traverse_in_order (current, flags, depth, func, data))
     return (!(0));

   if ((flags & G_TRAVERSE_NON_LEAFS) &&
       func (node, data))
     return (!(0));

   while (child)
     {
       current = child;
       child = current->next;
       if (g_node_depth_traverse_in_order (current, flags, depth, func, data))
  return (!(0));
     }
 }
      else if ((flags & G_TRAVERSE_NON_LEAFS) &&
        func (node, data))
 return (!(0));
    }
  else if ((flags & G_TRAVERSE_LEAFS) &&
    func (node, data))
    return (!(0));

  return (0);
}

static gboolean
g_node_traverse_level (GNode *node,
         GTraverseFlags flags,
         guint level,
         GNodeTraverseFunc func,
         gpointer data,
         gboolean *more_levels)
{
  if (level == 0)
    {
      if (node->children)
 {
   *more_levels = (!(0));
   return (flags & G_TRAVERSE_NON_LEAFS) && func (node, data);
 }
      else
 {
   return (flags & G_TRAVERSE_LEAFS) && func (node, data);
 }
    }
  else
    {
      node = node->children;

      while (node)
 {
   if (g_node_traverse_level (node, flags, level - 1, func, data, more_levels))
     return (!(0));

   node = node->next;
 }
    }

  return (0);
}

static gboolean
g_node_depth_traverse_level (GNode *node,
        GTraverseFlags flags,
        guint depth,
        GNodeTraverseFunc func,
        gpointer data)
{
  guint level;
  gboolean more_levels;

  level = 0;
  while (level != depth)
    {
      more_levels = (0);
      if (g_node_traverse_level (node, flags, level, func, data, &more_levels))
 return (!(0));
      if (!more_levels)
 break;
      level++;
    }
  return (0);
}
# 850 "gnode.c"
void
g_node_traverse (GNode *root,
   GTraverseType order,
   GTraverseFlags flags,
   gint depth,
   GNodeTraverseFunc func,
   gpointer data)
{
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (root != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "root != NULL"); return; }; }while (0);
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (func != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "func != NULL"); return; }; }while (0);
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (order <= G_LEVEL_ORDER) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "order <= G_LEVEL_ORDER"); return; }; }while (0);
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (flags <= G_TRAVERSE_MASK) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "flags <= G_TRAVERSE_MASK"); return; }; }while (0);
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (depth == -1 || depth > 0) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "depth == -1 || depth > 0"); return; }; }while (0);

  switch (order)
    {
    case G_PRE_ORDER:
      if (depth < 0)
 g_node_traverse_pre_order (root, flags, func, data);
      else
 g_node_depth_traverse_pre_order (root, flags, depth, func, data);
      break;
    case G_POST_ORDER:
      if (depth < 0)
 g_node_traverse_post_order (root, flags, func, data);
      else
 g_node_depth_traverse_post_order (root, flags, depth, func, data);
      break;
    case G_IN_ORDER:
      if (depth < 0)
 g_node_traverse_in_order (root, flags, func, data);
      else
 g_node_depth_traverse_in_order (root, flags, depth, func, data);
      break;
    case G_LEVEL_ORDER:
      g_node_depth_traverse_level (root, flags, depth, func, data);
      break;
    }
}

static gboolean
g_node_find_func (GNode *node,
    gpointer data)
{
  gpointer *d = data;

  if (*d != node->data)
    return (0);

  *(++d) = node;

  return (!(0));
}
# 917 "gnode.c"
GNode*
g_node_find (GNode *root,
      GTraverseType order,
      GTraverseFlags flags,
      gpointer data)
{
  gpointer d[2];

  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (root != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "root != NULL"); return (((void *)0)); }; }while (0);
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (order <= G_LEVEL_ORDER) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "order <= G_LEVEL_ORDER"); return (((void *)0)); }; }while (0);
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (flags <= G_TRAVERSE_MASK) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "flags <= G_TRAVERSE_MASK"); return (((void *)0)); }; }while (0);

  d[0] = data;
  d[1] = ((void *)0);

  g_node_traverse (root, order, flags, -1, g_node_find_func, d);

  return d[1];
}

static void
g_node_count_func (GNode *node,
     GTraverseFlags flags,
     guint *n)
{
  if (node->children)
    {
      GNode *child;

      if (flags & G_TRAVERSE_NON_LEAFS)
 (*n)++;

      child = node->children;
      while (child)
 {
   g_node_count_func (child, flags, n);
   child = child->next;
 }
    }
  else if (flags & G_TRAVERSE_LEAFS)
    (*n)++;
}
# 970 "gnode.c"
guint
g_node_n_nodes (GNode *root,
  GTraverseFlags flags)
{
  guint n = 0;

  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (root != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "root != NULL"); return (0); }; }while (0);
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (flags <= G_TRAVERSE_MASK) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "flags <= G_TRAVERSE_MASK"); return (0); }; }while (0);

  g_node_count_func (root, flags, &n);

  return n;
}
# 992 "gnode.c"
GNode*
g_node_last_child (GNode *node)
{
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (node != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "node != NULL"); return (((void *)0)); }; }while (0);

  node = node->children;
  if (node)
    while (node->next)
      node = node->next;

  return node;
}
# 1016 "gnode.c"
GNode*
g_node_nth_child (GNode *node,
    guint n)
{
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (node != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "node != NULL"); return (((void *)0)); }; }while (0);

  node = node->children;
  if (node)
    while ((n-- > 0) && node)
      node = node->next;

  return node;
}
# 1038 "gnode.c"
guint
g_node_n_children (GNode *node)
{
  guint n = 0;

  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (node != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "node != NULL"); return (0); }; }while (0);

  node = node->children;
  while (node)
    {
      n++;
      node = node->next;
    }

  return n;
}
# 1066 "gnode.c"
GNode*
g_node_find_child (GNode *node,
     GTraverseFlags flags,
     gpointer data)
{
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (node != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "node != NULL"); return (((void *)0)); }; }while (0);
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (flags <= G_TRAVERSE_MASK) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "flags <= G_TRAVERSE_MASK"); return (((void *)0)); }; }while (0);

  node = node->children;
  while (node)
    {
      if (node->data == data)
 {
   if ((((GNode*) (node))->children == ((void *)0)))
     {
       if (flags & G_TRAVERSE_LEAFS)
  return node;
     }
   else
     {
       if (flags & G_TRAVERSE_NON_LEAFS)
  return node;
     }
 }
      node = node->next;
    }

  return ((void *)0);
}
# 1107 "gnode.c"
gint
g_node_child_position (GNode *node,
         GNode *child)
{
  guint n = 0;

  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (node != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "node != NULL"); return (-1); }; }while (0);
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (child != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "child != NULL"); return (-1); }; }while (0);
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (child->parent == node) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "child->parent == node"); return (-1); }; }while (0);

  node = node->children;
  while (node)
    {
      if (node == child)
 return n;
      n++;
      node = node->next;
    }

  return -1;
}
# 1140 "gnode.c"
gint
g_node_child_index (GNode *node,
      gpointer data)
{
  guint n = 0;

  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (node != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "node != NULL"); return (-1); }; }while (0);

  node = node->children;
  while (node)
    {
      if (node->data == data)
 return n;
      n++;
      node = node->next;
    }

  return -1;
}
# 1169 "gnode.c"
GNode*
g_node_first_sibling (GNode *node)
{
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (node != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "node != NULL"); return (((void *)0)); }; }while (0);

  if (node->parent)
    return node->parent->children;

  while (node->prev)
    node = node->prev;

  return node;
}
# 1192 "gnode.c"
GNode*
g_node_last_sibling (GNode *node)
{
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (node != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "node != NULL"); return (((void *)0)); }; }while (0);

  while (node->next)
    node = node->next;

  return node;
}
# 1223 "gnode.c"
void
g_node_children_foreach (GNode *node,
    GTraverseFlags flags,
    GNodeForeachFunc func,
    gpointer data)
{
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (node != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "node != NULL"); return; }; }while (0);
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (flags <= G_TRAVERSE_MASK) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "flags <= G_TRAVERSE_MASK"); return; }; }while (0);
  do{ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (func != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib", __PRETTY_FUNCTION__, "func != NULL"); return; }; }while (0);

  node = node->children;
  while (node)
    {
      GNode *current;

      current = node;
      node = current->next;
      if ((((GNode*) (current))->children == ((void *)0)))
 {
   if (flags & G_TRAVERSE_LEAFS)
     func (current, data);
 }
      else
 {
   if (flags & G_TRAVERSE_NON_LEAFS)
     func (current, data);
 }
    }
}

int main (int argc, char *argv[]) {

}
